home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / awt / EventQueue.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  10.2 KB  |  608 lines
  1. package java.awt;
  2.  
  3. import java.awt.event.ActionEvent;
  4. import java.awt.event.FocusEvent;
  5. import java.awt.event.InputEvent;
  6. import java.awt.event.InputMethodEvent;
  7. import java.awt.event.InvocationEvent;
  8. import java.awt.event.KeyEvent;
  9. import java.awt.event.MouseEvent;
  10. import java.awt.event.PaintEvent;
  11. import java.awt.event.WindowEvent;
  12. import java.awt.peer.ComponentPeer;
  13. import java.lang.ref.WeakReference;
  14. import java.lang.reflect.InvocationTargetException;
  15. import java.security.AccessController;
  16. import java.util.EmptyStackException;
  17. import sun.awt.AWTAutoShutdown;
  18. import sun.awt.AppContext;
  19. import sun.awt.DebugHelper;
  20. import sun.awt.PeerEvent;
  21. import sun.awt.SunToolkit;
  22.  
  23. public class EventQueue {
  24.    private static final DebugHelper dbg = DebugHelper.create(EventQueue.class);
  25.    private static int threadInitNumber;
  26.    private static final int LOW_PRIORITY = 0;
  27.    private static final int NORM_PRIORITY = 1;
  28.    private static final int HIGH_PRIORITY = 2;
  29.    private static final int ULTIMATE_PRIORITY = 3;
  30.    private static final int NUM_PRIORITIES = 4;
  31.    private Queue[] queues = new Queue[4];
  32.    private EventQueue nextQueue;
  33.    private EventQueue previousQueue;
  34.    private EventDispatchThread dispatchThread;
  35.    private final ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
  36.    private final ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
  37.    private static final boolean debug = false;
  38.    private long mostRecentEventTime = System.currentTimeMillis();
  39.    private WeakReference currentEvent;
  40.    private int waitForID;
  41.    private final String name = "AWT-EventQueue-" + nextThreadNum();
  42.    private static final int PAINT = 0;
  43.    private static final int UPDATE = 1;
  44.    private static final int MOVE = 2;
  45.    private static final int DRAG = 3;
  46.    private static final int PEER = 4;
  47.    private static final int CACHE_LENGTH = 5;
  48.  
  49.    private static synchronized int nextThreadNum() {
  50.       return threadInitNumber++;
  51.    }
  52.  
  53.    public EventQueue() {
  54.       for(int var1 = 0; var1 < 4; ++var1) {
  55.          this.queues[var1] = new Queue();
  56.       }
  57.  
  58.    }
  59.  
  60.    public void postEvent(AWTEvent var1) {
  61.       SunToolkit.flushPendingEvents();
  62.       this.postEventPrivate(var1);
  63.    }
  64.  
  65.    final void postEventPrivate(AWTEvent var1) {
  66.       var1.isPosted = true;
  67.       synchronized(this) {
  68.          if (this.dispatchThread == null && this.nextQueue == null) {
  69.             if (var1.getSource() == AWTAutoShutdown.getInstance()) {
  70.                return;
  71.             }
  72.  
  73.             this.initDispatchThread();
  74.          }
  75.  
  76.          if (this.nextQueue != null) {
  77.             this.nextQueue.postEventPrivate(var1);
  78.          } else {
  79.             this.postEvent(var1, getPriority(var1));
  80.          }
  81.       }
  82.    }
  83.  
  84.    private static int getPriority(AWTEvent var0) {
  85.       if (var0 instanceof PeerEvent && (((PeerEvent)var0).getFlags() & 2L) != 0L) {
  86.          return 3;
  87.       } else if (var0 instanceof PeerEvent && (((PeerEvent)var0).getFlags() & 1L) != 0L) {
  88.          return 2;
  89.       } else if (var0 instanceof PeerEvent && (((PeerEvent)var0).getFlags() & 4L) != 0L) {
  90.          return 0;
  91.       } else {
  92.          int var1 = var0.getID();
  93.          return var1 != 800 && var1 != 801 ? 1 : 0;
  94.       }
  95.    }
  96.  
  97.    private void postEvent(AWTEvent var1, int var2) {
  98.       Object var3 = var1.getSource();
  99.       if (!this.coalesceEvent(var1, var2)) {
  100.          EventQueueItem var4 = new EventQueueItem(var1);
  101.          this.cacheEQItem(var4);
  102.          boolean var5 = var1.getID() == this.waitForID;
  103.          if (this.queues[var2].head == null) {
  104.             boolean var6 = this.noEvents();
  105.             this.queues[var2].head = this.queues[var2].tail = var4;
  106.             if (var6) {
  107.                if (var1.getSource() != AWTAutoShutdown.getInstance()) {
  108.                   AWTAutoShutdown.getInstance().notifyThreadBusy(this.dispatchThread);
  109.                }
  110.  
  111.                this.notifyAll();
  112.             } else if (var5) {
  113.                this.notifyAll();
  114.             }
  115.          } else {
  116.             this.queues[var2].tail.next = var4;
  117.             this.queues[var2].tail = var4;
  118.             if (var5) {
  119.                this.notifyAll();
  120.             }
  121.          }
  122.  
  123.       }
  124.    }
  125.  
  126.    private boolean coalescePaintEvent(PaintEvent var1) {
  127.       ComponentPeer var2 = ((Component)var1.getSource()).peer;
  128.       if (var2 != null) {
  129.          var2.coalescePaintEvent(var1);
  130.       }
  131.  
  132.       EventQueueItem[] var3 = ((Component)var1.getSource()).eventCache;
  133.       if (var3 == null) {
  134.          return false;
  135.       } else {
  136.          int var4 = eventToCacheIndex(var1);
  137.          if (var4 != -1 && var3[var4] != null) {
  138.             PaintEvent var5 = this.mergePaintEvents(var1, (PaintEvent)var3[var4].event);
  139.             if (var5 != null) {
  140.                var3[var4].event = var5;
  141.                return true;
  142.             }
  143.          }
  144.  
  145.          return false;
  146.       }
  147.    }
  148.  
  149.    private PaintEvent mergePaintEvents(PaintEvent var1, PaintEvent var2) {
  150.       Rectangle var3 = var1.getUpdateRect();
  151.       Rectangle var4 = var2.getUpdateRect();
  152.       if (var4.contains(var3)) {
  153.          return var2;
  154.       } else {
  155.          return var3.contains(var4) ? var1 : null;
  156.       }
  157.    }
  158.  
  159.    private boolean coalesceMouseEvent(MouseEvent var1) {
  160.       EventQueueItem[] var2 = ((Component)var1.getSource()).eventCache;
  161.       if (var2 == null) {
  162.          return false;
  163.       } else {
  164.          int var3 = eventToCacheIndex(var1);
  165.          if (var3 != -1 && var2[var3] != null) {
  166.             var2[var3].event = var1;
  167.             return true;
  168.          } else {
  169.             return false;
  170.          }
  171.       }
  172.    }
  173.  
  174.    private boolean coalescePeerEvent(PeerEvent var1) {
  175.       EventQueueItem[] var2 = ((Component)var1.getSource()).eventCache;
  176.       if (var2 == null) {
  177.          return false;
  178.       } else {
  179.          int var3 = eventToCacheIndex(var1);
  180.          if (var3 != -1 && var2[var3] != null) {
  181.             var1 = var1.coalesceEvents((PeerEvent)var2[var3].event);
  182.             if (var1 != null) {
  183.                var2[var3].event = var1;
  184.                return true;
  185.             }
  186.  
  187.             var2[var3] = null;
  188.          }
  189.  
  190.          return false;
  191.       }
  192.    }
  193.  
  194.    private boolean coalesceOtherEvent(AWTEvent var1, int var2) {
  195.       int var3 = var1.getID();
  196.       Component var4 = (Component)var1.getSource();
  197.  
  198.       for(EventQueueItem var5 = this.queues[var2].head; var5 != null; var5 = var5.next) {
  199.          if (var5.event.getSource() == var4 && var5.id == var3) {
  200.             AWTEvent var6 = var4.coalesceEvents(var5.event, var1);
  201.             if (var6 != null) {
  202.                var5.event = var6;
  203.                return true;
  204.             }
  205.          }
  206.       }
  207.  
  208.       return false;
  209.    }
  210.  
  211.    private boolean coalesceEvent(AWTEvent var1, int var2) {
  212.       if (!(var1.getSource() instanceof Component)) {
  213.          return false;
  214.       } else if (var1 instanceof PeerEvent) {
  215.          return this.coalescePeerEvent((PeerEvent)var1);
  216.       } else if (((Component)var1.getSource()).isCoalescingEnabled() && this.coalesceOtherEvent(var1, var2)) {
  217.          return true;
  218.       } else if (var1 instanceof PaintEvent) {
  219.          return this.coalescePaintEvent((PaintEvent)var1);
  220.       } else {
  221.          return var1 instanceof MouseEvent ? this.coalesceMouseEvent((MouseEvent)var1) : false;
  222.       }
  223.    }
  224.  
  225.    private void cacheEQItem(EventQueueItem var1) {
  226.       int var2 = eventToCacheIndex(var1.event);
  227.       if (var2 != -1 && var1.event.getSource() instanceof Component) {
  228.          Component var3 = (Component)var1.event.getSource();
  229.          if (var3.eventCache == null) {
  230.             var3.eventCache = new EventQueueItem[5];
  231.          }
  232.  
  233.          var3.eventCache[var2] = var1;
  234.       }
  235.  
  236.    }
  237.  
  238.    private void uncacheEQItem(EventQueueItem var1) {
  239.       int var2 = eventToCacheIndex(var1.event);
  240.       if (var2 != -1 && var1.event.getSource() instanceof Component) {
  241.          Component var3 = (Component)var1.event.getSource();
  242.          if (var3.eventCache == null) {
  243.             return;
  244.          }
  245.  
  246.          var3.eventCache[var2] = null;
  247.       }
  248.  
  249.    }
  250.  
  251.    private static int eventToCacheIndex(AWTEvent var0) {
  252.       switch (var0.getID()) {
  253.          case 503:
  254.             return 2;
  255.          case 506:
  256.             return 3;
  257.          case 800:
  258.             return 0;
  259.          case 801:
  260.             return 1;
  261.          default:
  262.             return var0 instanceof PeerEvent ? 4 : -1;
  263.       }
  264.    }
  265.  
  266.    private boolean noEvents() {
  267.       for(int var1 = 0; var1 < 4; ++var1) {
  268.          if (this.queues[var1].head != null) {
  269.             return false;
  270.          }
  271.       }
  272.  
  273.       return true;
  274.    }
  275.  
  276.    public AWTEvent getNextEvent() throws InterruptedException {
  277.       while(true) {
  278.          SunToolkit.flushPendingEvents();
  279.          synchronized(this) {
  280.             for(int var2 = 3; var2 >= 0; --var2) {
  281.                if (this.queues[var2].head != null) {
  282.                   EventQueueItem var3 = this.queues[var2].head;
  283.                   this.queues[var2].head = var3.next;
  284.                   if (var3.next == null) {
  285.                      this.queues[var2].tail = null;
  286.                   }
  287.  
  288.                   this.uncacheEQItem(var3);
  289.                   return var3.event;
  290.                }
  291.             }
  292.  
  293.             AWTAutoShutdown.getInstance().notifyThreadFree(this.dispatchThread);
  294.             this.wait();
  295.          }
  296.       }
  297.    }
  298.  
  299.    AWTEvent getNextEvent(int var1) throws InterruptedException {
  300.       while(true) {
  301.          SunToolkit.flushPendingEvents();
  302.          synchronized(this) {
  303.             for(int var3 = 0; var3 < 4; ++var3) {
  304.                EventQueueItem var4 = this.queues[var3].head;
  305.  
  306.                for(EventQueueItem var5 = null; var4 != null; var4 = var4.next) {
  307.                   if (var4.id == var1) {
  308.                      if (var5 == null) {
  309.                         this.queues[var3].head = var4.next;
  310.                      } else {
  311.                         var5.next = var4.next;
  312.                      }
  313.  
  314.                      if (this.queues[var3].tail == var4) {
  315.                         this.queues[var3].tail = var5;
  316.                      }
  317.  
  318.                      this.uncacheEQItem(var4);
  319.                      return var4.event;
  320.                   }
  321.  
  322.                   var5 = var4;
  323.                }
  324.             }
  325.  
  326.             this.waitForID = var1;
  327.             this.wait();
  328.             this.waitForID = 0;
  329.          }
  330.       }
  331.    }
  332.  
  333.    public synchronized AWTEvent peekEvent() {
  334.       for(int var1 = 3; var1 >= 0; --var1) {
  335.          if (this.queues[var1].head != null) {
  336.             return this.queues[var1].head.event;
  337.          }
  338.       }
  339.  
  340.       return null;
  341.    }
  342.  
  343.    public synchronized AWTEvent peekEvent(int var1) {
  344.       for(int var2 = 3; var2 >= 0; --var2) {
  345.          for(EventQueueItem var3 = this.queues[var2].head; var3 != null; var3 = var3.next) {
  346.             if (var3.id == var1) {
  347.                return var3.event;
  348.             }
  349.          }
  350.       }
  351.  
  352.       return null;
  353.    }
  354.  
  355.    protected void dispatchEvent(AWTEvent var1) {
  356.       var1.isPosted = true;
  357.       Object var2 = var1.getSource();
  358.       if (var1 instanceof ActiveEvent) {
  359.          this.setCurrentEventAndMostRecentTimeImpl(var1);
  360.          ((ActiveEvent)var1).dispatch();
  361.       } else if (var2 instanceof Component) {
  362.          ((Component)var2).dispatchEvent(var1);
  363.          var1.dispatched();
  364.       } else if (var2 instanceof MenuComponent) {
  365.          ((MenuComponent)var2).dispatchEvent(var1);
  366.       } else if (var2 instanceof TrayIcon) {
  367.          ((TrayIcon)var2).dispatchEvent(var1);
  368.       } else if (var2 instanceof AWTAutoShutdown) {
  369.          if (this.noEvents()) {
  370.             this.dispatchThread.stopDispatching();
  371.          }
  372.       } else {
  373.          System.err.println("unable to dispatch event: " + var1);
  374.       }
  375.  
  376.    }
  377.  
  378.    public static long getMostRecentEventTime() {
  379.       return Toolkit.getEventQueue().getMostRecentEventTimeImpl();
  380.    }
  381.  
  382.    private synchronized long getMostRecentEventTimeImpl() {
  383.       return Thread.currentThread() == this.dispatchThread ? this.mostRecentEventTime : System.currentTimeMillis();
  384.    }
  385.  
  386.    synchronized long getMostRecentEventTimeEx() {
  387.       return this.mostRecentEventTime;
  388.    }
  389.  
  390.    public static AWTEvent getCurrentEvent() {
  391.       return Toolkit.getEventQueue().getCurrentEventImpl();
  392.    }
  393.  
  394.    private synchronized AWTEvent getCurrentEventImpl() {
  395.       return Thread.currentThread() == this.dispatchThread ? (AWTEvent)this.currentEvent.get() : null;
  396.    }
  397.  
  398.    public synchronized void push(EventQueue var1) {
  399.       if (this.nextQueue != null) {
  400.          this.nextQueue.push(var1);
  401.       } else {
  402.          synchronized(var1) {
  403.             while(this.peekEvent() != null) {
  404.                try {
  405.                   var1.postEventPrivate(this.getNextEvent());
  406.                } catch (InterruptedException var5) {
  407.                }
  408.             }
  409.  
  410.             var1.previousQueue = this;
  411.          }
  412.  
  413.          if (this.dispatchThread != null) {
  414.             this.dispatchThread.stopDispatchingLater();
  415.          }
  416.  
  417.          this.nextQueue = var1;
  418.          AppContext var2 = AppContext.getAppContext();
  419.          if (var2.get(AppContext.EVENT_QUEUE_KEY) == this) {
  420.             var2.put(AppContext.EVENT_QUEUE_KEY, var1);
  421.          }
  422.  
  423.       }
  424.    }
  425.  
  426.    protected void pop() throws EmptyStackException {
  427.       EventQueue var1 = this.previousQueue;
  428.       synchronized(var1 != null ? var1 : this) {
  429.          label61: {
  430.             synchronized(this) {
  431.                if (this.nextQueue == null) {
  432.                   if (this.previousQueue == null) {
  433.                      throw new EmptyStackException();
  434.                   }
  435.  
  436.                   this.previousQueue.nextQueue = null;
  437.  
  438.                   while(this.peekEvent() != null) {
  439.                      try {
  440.                         this.previousQueue.postEventPrivate(this.getNextEvent());
  441.                      } catch (InterruptedException var7) {
  442.                      }
  443.                   }
  444.  
  445.                   AppContext var4 = AppContext.getAppContext();
  446.                   if (var4.get(AppContext.EVENT_QUEUE_KEY) == this) {
  447.                      var4.put(AppContext.EVENT_QUEUE_KEY, this.previousQueue);
  448.                   }
  449.  
  450.                   this.previousQueue = null;
  451.                   break label61;
  452.                }
  453.  
  454.                this.nextQueue.pop();
  455.             }
  456.  
  457.             return;
  458.          }
  459.       }
  460.  
  461.       EventDispatchThread var2 = this.dispatchThread;
  462.       if (var2 != null) {
  463.          var2.stopDispatching();
  464.       }
  465.  
  466.    }
  467.  
  468.    public static boolean isDispatchThread() {
  469.       EventQueue var0 = Toolkit.getEventQueue();
  470.  
  471.       for(EventQueue var1 = var0.nextQueue; var1 != null; var1 = var1.nextQueue) {
  472.          var0 = var1;
  473.       }
  474.  
  475.       return Thread.currentThread() == var0.dispatchThread;
  476.    }
  477.  
  478.    final void initDispatchThread() {
  479.       synchronized(this) {
  480.          if (this.dispatchThread == null && !this.threadGroup.isDestroyed()) {
  481.             this.dispatchThread = (EventDispatchThread)AccessController.doPrivileged(new 1(this));
  482.             AWTAutoShutdown.getInstance().notifyThreadBusy(this.dispatchThread);
  483.             this.dispatchThread.start();
  484.          }
  485.  
  486.       }
  487.    }
  488.  
  489.    final void detachDispatchThread() {
  490.       this.dispatchThread = null;
  491.    }
  492.  
  493.    final EventDispatchThread getDispatchThread() {
  494.       return this.dispatchThread;
  495.    }
  496.  
  497.    final void removeSourceEvents(Object var1, boolean var2) {
  498.       SunToolkit.flushPendingEvents();
  499.       synchronized(this) {
  500.          for(int var4 = 0; var4 < 4; ++var4) {
  501.             EventQueueItem var5 = this.queues[var4].head;
  502.  
  503.             EventQueueItem var6;
  504.             for(var6 = null; var5 != null; var5 = var5.next) {
  505.                if (var5.event.getSource() == var1 && (var2 || !(var5.event instanceof SequencedEvent) && !(var5.event instanceof SentEvent) && !(var5.event instanceof FocusEvent) && !(var5.event instanceof WindowEvent) && !(var5.event instanceof KeyEvent) && !(var5.event instanceof InputMethodEvent))) {
  506.                   if (var5.event instanceof SequencedEvent) {
  507.                      ((SequencedEvent)var5.event).dispose();
  508.                   }
  509.  
  510.                   if (var5.event instanceof SentEvent) {
  511.                      ((SentEvent)var5.event).dispose();
  512.                   }
  513.  
  514.                   if (var6 == null) {
  515.                      this.queues[var4].head = var5.next;
  516.                   } else {
  517.                      var6.next = var5.next;
  518.                   }
  519.  
  520.                   this.uncacheEQItem(var5);
  521.                } else {
  522.                   var6 = var5;
  523.                }
  524.             }
  525.  
  526.             this.queues[var4].tail = var6;
  527.          }
  528.  
  529.       }
  530.    }
  531.  
  532.    static void setCurrentEventAndMostRecentTime(AWTEvent var0) {
  533.       Toolkit.getEventQueue().setCurrentEventAndMostRecentTimeImpl(var0);
  534.    }
  535.  
  536.    private synchronized void setCurrentEventAndMostRecentTimeImpl(AWTEvent var1) {
  537.       if (Thread.currentThread() == this.dispatchThread) {
  538.          this.currentEvent = new WeakReference(var1);
  539.          long var2 = Long.MIN_VALUE;
  540.          if (var1 instanceof InputEvent) {
  541.             InputEvent var4 = (InputEvent)var1;
  542.             var2 = var4.getWhen();
  543.          } else if (var1 instanceof InputMethodEvent) {
  544.             InputMethodEvent var5 = (InputMethodEvent)var1;
  545.             var2 = var5.getWhen();
  546.          } else if (var1 instanceof ActionEvent) {
  547.             ActionEvent var6 = (ActionEvent)var1;
  548.             var2 = var6.getWhen();
  549.          } else if (var1 instanceof InvocationEvent) {
  550.             InvocationEvent var7 = (InvocationEvent)var1;
  551.             var2 = var7.getWhen();
  552.          }
  553.  
  554.          this.mostRecentEventTime = Math.max(this.mostRecentEventTime, var2);
  555.       }
  556.    }
  557.  
  558.    public static void invokeLater(Runnable var0) {
  559.       Toolkit.getEventQueue().postEvent(new InvocationEvent(Toolkit.getDefaultToolkit(), var0));
  560.    }
  561.  
  562.    public static void invokeAndWait(Runnable var0) throws InterruptedException, InvocationTargetException {
  563.       if (isDispatchThread()) {
  564.          throw new Error("Cannot call invokeAndWait from the event dispatcher thread");
  565.       } else {
  566.          1AWTInvocationLock var1 = new 1AWTInvocationLock();
  567.          InvocationEvent var2 = new InvocationEvent(Toolkit.getDefaultToolkit(), var0, var1, true);
  568.          synchronized(var1) {
  569.             Toolkit.getEventQueue().postEvent(var2);
  570.             var1.wait();
  571.          }
  572.  
  573.          Throwable var3 = var2.getThrowable();
  574.          if (var3 != null) {
  575.             throw new InvocationTargetException(var3);
  576.          }
  577.       }
  578.    }
  579.  
  580.    private void wakeup(boolean var1) {
  581.       synchronized(this) {
  582.          if (this.nextQueue != null) {
  583.             this.nextQueue.wakeup(var1);
  584.          } else if (this.dispatchThread != null) {
  585.             this.notifyAll();
  586.          } else if (!var1) {
  587.             this.initDispatchThread();
  588.          }
  589.  
  590.       }
  591.    }
  592.  
  593.    // $FF: synthetic method
  594.    static ThreadGroup access$000(EventQueue var0) {
  595.       return var0.threadGroup;
  596.    }
  597.  
  598.    // $FF: synthetic method
  599.    static String access$100(EventQueue var0) {
  600.       return var0.name;
  601.    }
  602.  
  603.    // $FF: synthetic method
  604.    static ClassLoader access$200(EventQueue var0) {
  605.       return var0.classLoader;
  606.    }
  607. }
  608.